设计模式 - 代理

注意：所有文章除特别说明外，转载请注明出处.

简介

该模式中一个类代表另一个类的功能，我们创建具有现有对象的对象，以便向外界提供功能接口。

注意：该模式和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。该模式和装饰器模式的区别：装饰器模式为了增强功能，而代理模式为了加以控制。

提示：是最常用的模式之一，用一个代理来隐藏具体实现细节，通常还用于在真实的实现前后添加一部分逻辑。

代理模式

1.创建接口

public interface Image {
    void display();
}

2.创建实现接口的实体类

public class RealImage implements Image {

   private String fileName;

   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }

   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }

   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}

//这里的代理要表现得就像是真实类
public class ProxyImage implements Image{

   //在内部需要一个真实实现类
   private RealImage realImage;

   private String fileName;

   public ProxyImage(String fileName){
      this.fileName = fileName;
   }

   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}

3.当被请求时 使用 ProxyImage 来获取 RealImage 类的对象

public class ProxyPatternDemo {
   public static void main(String[] args) {
      Image image = new ProxyImage("test_10mb.jpg");

      // 图像将从磁盘加载
      image.display(); 
      System.out.println("");
      // 图像不需要从磁盘加载
      image.display();  
   }
}

总结

代理在实际意义上就是 方法包装 和 方法增强。在AOP中就是动态代理的过程。

1.JDK动态代理

1.java.lang.reflect.Proxy 生成动态代理类和对象
2.java.lang.reflect.InvocationHandler(处理器接口) 可通过invoke()方法实现

注意：此动态代理对真实角色的代理访问，每次都是通过Proxy生成的代理类对象都要指定对应的处理器对象。

1.接口

    public interface Subject {
        public int sellBooks();
        public String speak();
    }

2.真实对象

    public class RealSubject implements Subject {
        @Override 
        public int sellBooks(){
            System.out.println("sellbooks");
            return 1;
        }

        @Override
        public String speak() {
            System.out.println("说话");
            return "张三";
        }
    }

3.处理对象

    public class MyInvocationHandler implements InvocationHandler {

        //这里需要处理真实角色 所以传入真实角色
        Subject realSubject;

        public MyInvocationHandler(Subject subject){
            this.realSubject = subject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("调用代理类");
            if(method.getName().equals("sellBooks")){
                int invoke = (int)method.invoke(realSubject, args);
                System.out.println("调用的是卖书的方法");
                return invoke ;
            }else {
                String string = (String) method.invoke(realSubject,args) ;
                System.out.println("调用的是说话的方法");
                return  string ;
            }
        }
    }

4.调用 main.java

    public class Client {
        public static void main(String[] args){
            //真实对象
            Subject subject = new RealSubject();

            MyInvocationHandler myInvocationHandler = new MyInvocationHandler(realSubject);

            //代理对象
            Subject proxyClass = (Subject) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader, new Class[]{Subject.class}, myInvocationHandler);

            proxyClass.sellBooks();
            proxyClass.speak();
        }
    }

2.Cglib动态代理

1.被代理类

    public class Engineer {
        //该方法可以被代理
        public void eat(){
            System.out.println("正在吃饭...");
        }

        //final方法不会被生成的子类覆盖
        public final void work(){
            System.out.println("正在工作...");
        }

        //private方法不会被生成的子类覆盖
        private void play(){
            System.out.println("正在玩耍...");
        }
    }

2.cglib代理类

    ...
    public class CglibProxy implements MethodInterceptor {
        private Object target;

        public CglibProxy(Object target){
            this.target = target;
        }

        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("###   before invocation");
            Object result = method.invoke(target, objects);
            System.out.println("###   end invocation");
            return result;
        }

        public static Object getProxy(Object target) {
        Enhancer enhancer = new Enhancer();
        // 设置需要代理的对象
        enhancer.setSuperclass(target.getClass());
        // 设置代理人
        enhancer.setCallback(new CglibProxy(target));
        return enhancer.create();

        }
    }

3.测试

    public class CglibMainTest {
        public static void main(String[] args) {
            // 生成 Cglib 代理类
            Engineer engineerProxy = (Engineer) CglibProxy.getProxy(new Engineer());
            // 调用相关方法
            engineerProxy.eat();
        }
    }